package com.t.bricks.bussiness.service.orderdetail.impl;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.t.bricks.bussiness.db.dao.orderdetail.OrderDetailDao;
import com.t.bricks.bussiness.db.entity.orderdetail.OrderDetail;
import com.t.bricks.bussiness.db.entity.orderdetail.base.OrderDetailBase;
import com.t.bricks.bussiness.model.orderdetail.ConditionOrderDetail;
import com.t.bricks.bussiness.model.orderdetail.OrderInfo;
import com.t.bricks.bussiness.service.orderdetail.OrderDetailService;
import com.t.bricks.model.MsgEmity;
import com.t.bricks.model.OrderInfoList;
import com.t.bricks.model.Page;
import com.t.bricks.utils.function.file.ZipUtil;
import com.t.bricks.utils.spring.ModuleUtil;

/**
 * 订单详情'OrderDetail表'基本业务操作类接口实现
 */
@Service
public class OrderDetailServiceImpl implements OrderDetailService {

	@Autowired
	private OrderDetailDao orderDetailDao;

	/**
	 * 新增
	 * @param orderDetail 订单详情 对象实体,注意:跨包访问时可能会是json字符串
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity add(Object orderDetail) {
		MsgEmity me = ModuleUtil.objToEntity(orderDetail, OrderDetail.class);//转换数据,因为如果传递的是String,则可能是进行了跨包访问,要先用Json转换成实体对象
		if (!me.isSuccess()) {
			return me;
		}
		
		OrderDetail orderDetailData = me.getData();
		
		me = ModuleUtil.validDbEntityByAdd(orderDetailData);// 通用的基本数据验证,如果要进行比较复杂的数据验证则可以屏蔽掉此方法自行编写
		if (!me.isSuccess()) {
			return me;
		}
		
		me = ModuleUtil.validDbEntityRepeatByAdd((OrderDetailBase)orderDetailData, orderDetailDao);//查询数据库,验证数据是否有重复,因验证数据重复的方式比较复杂,直接在sql脚本中处理
		if (!me.isSuccess()) {// 在false下,如果返回8028则表示数据库查询异常,否则返回后4位是8026的数据,如xxx8026,从万位起表示从数据库中查询的结果
			String tmp = me.getData().toString();
			tmp = tmp.substring(tmp.length() -4, tmp.length());// 数据一定不小于4位
			return me.setData(tmp);// 发现重复数据后不进行其它业务处理则退出时,必须清理返回数据
		}
		
		orderDetailData.setsId(null);//清空记录编号
		
		me = ModuleUtil.supplyDbEntityAttrByAdd(orderDetailData);// 补充数据,如添加id、当前用户、当前时间等
		if (!me.isSuccess()) {
			return me;
		}
		
		return orderDetailDao.add(orderDetailData);
	}

	/**
	 * 删除
	 * @param sId 记录编号(订单编号+序号)
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity del(String sId) {
		if (null == sId || "".equals(sId.trim())) {
			return new MsgEmity(false, "信息编号参数错误，请刷新重试！", 8001);
		}
		
		return orderDetailDao.del(sId);
	}

	/**
	 * 修改
	 * @param orderDetail 订单详情 对象实体,注意:跨包访问时可能会是json字符串
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity edit(Object orderDetail) {
		MsgEmity me = ModuleUtil.objToEntity(orderDetail, OrderDetail.class);//转换数据,因为如果传递的是String,则可能是进行了跨包访问,要先用Json转换成实体对象
		if (!me.isSuccess()) {
			return me;
		}
		
		OrderDetail orderDetailData = me.getData();
		
		me = ModuleUtil.validBaseDataByEdit(orderDetailData);// 通用的基本数据验证(编辑),如果要进行比较复杂的数据验证则可以屏蔽掉此方法自行编写
		if (!me.isSuccess()) {
			return me;
		}
		
		me = ModuleUtil.validDbEntityRepeatByEdit((OrderDetailBase)orderDetailData, orderDetailDao);// 查询数据库,验证数据是否有重复,因验证数据重复的方式比较复杂,直接在sql脚本中处理
		if (!me.isSuccess()) {// 在false下,如果返回8028则表示数据库查询异常,否则返回后4位是8026的数据,如xxx8026,从万位起表示从数据库中查询的结果
			String tmp = me.getData().toString();
			tmp = tmp.substring(tmp.length() -4, tmp.length());//数据一定不小于4位
			return me.setData(tmp);// 发现重复数据后不进行其它业务处理则退出时,必须清理返回数据
		}
		
		ModuleUtil.supplyDbEntityAttrByEdit(orderDetailData);// 补充数据
		
		//--提交数据保存--//
		return orderDetailDao.edit(orderDetailData);//注意:更新成功后对象属性iVersion值将被+1
	}

	/**
	 * 根据记录编号取对象
	 * @param sId
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity findById(String sId) {
		if (null == sId || "".equals(sId.trim())) {
			return new MsgEmity(false, "编号不能为空！", 8001);
		}
		
		return orderDetailDao.findById(sId);
	}
	
	/**
	 * 根据字段名取指定记录编号的数据库表中对应字段的值
	 * @param sId 记录编号(订单编号+序号)
	 * @param fieldNames 待取数据的字段名称集合
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity getValueByFieldName(String sId, List<String> fieldNames) {
		if (null == sId || "".equals(sId.trim())) {
			return new MsgEmity(false, "编号不能为空！", 8001);
		}
		
		if (null == fieldNames || fieldNames.size() < 1) {
			return new MsgEmity(false, "待查询字段不能为空！", 8002);
		}
		
		return orderDetailDao.getValueByFieldName(sId, fieldNames);
	}
	
	/**
	 * 根据关键值取对象集合
	 * @param orderDetail 存放查询条件的OrderDetail(订单详情)对象实体,注意:跨包访问时可能会是json字符串
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity findByKey(Object orderDetail) {
		if (null == orderDetail) {
			return new MsgEmity(false, "条件不能为空！", 8000);
		}
		
		MsgEmity me = ModuleUtil.objToEntity(orderDetail, OrderDetail.class);//转换数据,因为如果传递的是String,则可能是进行了跨包访问,要先用Json转换成实体对象
		if (!me.isSuccess()) {
			return me;
		}
		
		OrderDetail orderDetailData = me.getData();
		
		return orderDetailDao.findByKey(orderDetailData);
	}

	/**
	 * 根据关键值查数量
	 * @Param orderDetail 存放查询条件的OrderDetail对象,注意:跨包访问时可能会是json字符串
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity findCountByKey(Object orderDetail) {
		if (null == orderDetail) {
			return new MsgEmity(false, "条件对象不能为空！", 8000);
		}
		
		MsgEmity me = ModuleUtil.objToEntity(orderDetail, OrderDetail.class);//转换数据,因为如果传递的是String,则可能是进行了跨包访问,要先用Json转换成实体对象
		if (!me.isSuccess()) {
			return me;
		}
		
		OrderDetail orderDetailData = me.getData();
		
		return orderDetailDao.findCountByKey(orderDetailData);
	}
	
	/**
	 * 查询分页
	 * @param page 分页信息对象
	 * @param orders 排序数据集合
	 * @param sLikeStr 全文检索
	 * @param condition 查询条件对象
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity findByPage(Page page, OrderInfoList orders, String sLikeStr,
			ConditionOrderDetail condition) {
		if (null == page) {
			page = new Page(new ArrayList<OrderDetail>());
		}

		return orderDetailDao.findByPage(page, orders, sLikeStr, condition);
	}

	/**
	 * 根据记录编号查询符合分页数据的某条记录
	 * @param sId
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity findByPageRow(String sId) {
		if (null == sId || "".equals(sId.trim())) {
			return new MsgEmity(false, "编号不能为空！", 8001);
		}
		
		return orderDetailDao.findByPageRow(sId);
	}

	/**
	 * 直接调用数据库操作
	 * @param args 参数集合,注意:参数不要使用基本类型
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity callMapping(Object...args) {
		String funName = ModuleUtil.parentMethodName();//待调用的mybits函数名与controller的接口名必须一致
		if (null == funName || "".equals(funName.trim())) {
			return new MsgEmity(false, "调用方法不明！", 8001);
		}
		
		if (null == args) {
			args = new Object[0];
		}
		
		Class<?>[] argsType = new Class<?>[args.length];
		for (int i = 0; i < args.length; i++) {
			argsType[i] = args[i].getClass();
		}
		
		return orderDetailDao.callMapping(funName, argsType, args);
	}

	/**
	 * 创建Excel文件内容
	 * @param orders 排序数据集合
	 * @param sLikeStr 全文检索
	 * @param condition 查询条件对象
	 * @return MsgEmity 返回结构中data为创建的经过压缩的Excel内容,接收端需要进行解压,msg为文件名
	 */
	@Override
	public MsgEmity export(OrderInfoList orders, String sLikeStr, ConditionOrderDetail condition) {
		MsgEmity me = orderDetailDao.findByExport(orders, sLikeStr, condition);//查询数据
		if(!me.isSuccess()) {
			return me;
		}
		
		me = ModuleUtil.crateExcel(me.getData(), "订单详情.xls");//根据Excel的xml模板创建文件内容
		if(!me.isSuccess()) {
			return me;
		}

		MsgEmity msg = ZipUtil.zipStr(me.getData());//将内容进行压缩,便于传输
		if(!msg.isSuccess()) {
			return msg.setData(100 + (Integer)msg.getData());//提升错误码值
		}
		
		return me.setData(msg.getData());//替换成压缩后的内容
	}
	
	//----------------------------- 自动生成代码结束 -----------------------------//
	
	/**
	 * 根据订单编号删除订单下所有明细
	 * @Param sOrderId
	 * @return int
	 */
	@Override
	public MsgEmity delByOrderId(String sOrderId) {
		if (null == sOrderId || "".equals(sOrderId.trim())) {
			return new MsgEmity(false, "订单编号参数错误，请刷新重试！", 8001);
		}
		
		return orderDetailDao.delByOrderId(sOrderId);
	}
	
	/**
	 * 批量新增数据
	 * @Param orderInfo 订单信息
	 * @return MsgEmity
	 */
	@Override
	public MsgEmity addList(OrderInfo orderInfo) {
		if (null == orderInfo) {
			return new MsgEmity(false, "订单信息参数错误！", 8001);
		}
		
		if (null == orderInfo.getsOrderId() || "".equals(orderInfo.getsOrderId().trim())) {
			return new MsgEmity(false, "订单编号参数错误，请刷新重试！", 8002);
		}
		
		if (null == orderInfo.getOrderDetails() || orderInfo.getOrderDetails().size() < 1) {
			return new MsgEmity(false, "信息集合参数不能为空，请刷新重试！", 8003);
		}
		
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < orderInfo.getOrderDetails().size(); i++) {
			OrderDetail orderDetail = orderInfo.getOrderDetails().get(i);
			
			if (null == orderDetail.getsGoodsId() || "".equals(orderDetail.getsGoodsId().trim())) {
				return new MsgEmity(false, "发现订单明细中有商品编号缺失！", 8004);
			}
			
			if (null == orderDetail.getsGoodsName() || "".equals(orderDetail.getsGoodsName().trim())) {
				return new MsgEmity(false, "发现订单明细中有商品名称缺失！", 8005);
			}
			
			if (null == orderDetail.getiNumber() || 1 > orderDetail.getiNumber()) {
				return new MsgEmity(false, "订单明细中商品数量不能小于1！", 8006);
			}
			
			if (null == orderDetail.getmPrice() || orderDetail.getmPrice().compareTo(BigDecimal.ZERO) == -1) {
				return new MsgEmity(false, "订单的商品售价小于0！", 8007);
			}
			
			sb.setLength(0);
			orderDetail.setsId(sb.append(orderInfo.getsOrderId()).append(String.format("%02d", (i +1))).toString());
			orderDetail.setsOrderId(orderInfo.getsOrderId());
		}
		
		return orderDetailDao.add(orderInfo.getOrderDetails());
	}

}
